Formalizing Resourve Allocation in a Compiler

On the basis of an A-normal form intermediate language we formally specify resource allocation in a compiler for a strict functional language. Here, resource is to be understood in the most general sense: registers, temporaries, data representations, etc. All these should be (and can be, but have never been) speciied formally. Our approach employs a non-standard annotated type system for the formalization. Although A-normal form turns out not to be the ideal vehicle for this investigation, we can prove some basic properties using the formalization. Resource allocation in the back end of a compiler is often poorly speciied. More often than not register allocation, administration of temporaries, and representation conversions are only speciied procedurally 1, 6]. Code generators based on such algorithmic speciications can be hard to maintain or prove correct. Even the authors of such code generators are sometimes not aware of all the invariants that must be preserved. Therefore, we investigate a declarative approach to resource allocation in the back end of a compiler. The approach is based on an annotated type system of implementation types that makes resource allocation and conversion explicit. The use of type conversion rules enables us to defer memory and register allocation until the context of use forces an allocation. For example, a constant initially leads to an annotation of the type of the variable holding the constant without generating any code. The annotation holds the \immediate value" of the constant. There are type conversion rules that change the annotation from \immediate value" to \value in register k" and generate a corresponding piece of code if the context of use requires the value of the variable in a register. Further conversion rules create or remove indirection. The indirection rules move a value to memory and change the annotation to \value in memory at address Rk]+i", where Rk] is an address in register k and i is an ooset. The indirection removing rules work the other way round. The indirection rules usually apply to the arguments of function calls or to values that are put into data structures. Spilling the contents of registers is another application of the last kind of conversion rules. Other rules may make direct use of immediate values, for example when generating instructions with immediate operands.